<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // push 在末端添加一个元素。

        // unshift 在首端添加一个元素。

        // shift 删除数组首端的一个元素。

        // pop 从末端删除一个元素。

        // splice 删除数组某一位置的元素。

        // concat 连接多个数组。

        // join 将数组转换为字符串

        // charAt() 获取相应位置的字符

        // charCodeAt() 指定位置字符 的 Unicode 编码

        // indexOf() 返回字符在字符串中的位置

        // lastIndexOf()

        // slice() 提取字符串的某个部分

        // substr() 截取字符串

        // toUpperCase()

        // toLowerCase()

        // forEach
        // 作用：用于遍历数组，对数组中的每一个元素进行某个操作。没有返回值，也不需要返回值。
        // foreach 像for循环一样，对数据进行遍历。
        // arr.forEach(function (item, index, array) {
        // ... do something with item
        // item 表示当前数组元素
        // index 表示元素对应的索引
        // array 表示当前数组，这个不常用
        // });、
        // ["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
        //     alert('' + item + ' is at index ' + index + ' in ' + array + '');
        // });


        // slice
        // slice() ：从数组中提取指定的一个或者多个元素，返回结果为新的数组（不会改变原来的数组）。
        // 备注：该方法不会改变原数组，而是将截取到的元素封装到一个新数组中返回。
        // 语法：
        // var result = 原数组.slice(开始位置的索引, 结束位置的索引); //注意：包含开始索引，不包含结束索引
        // 举例：
        // var arr = ["a", "b", "c", "d", "e", "f"];
        // var result1 = arr.slice(2); //从下标为2值开始提取
        // var result2 = arr.slice(-2); //提取最后两个元素
        // var result3 = arr.slice(2, 4); //提取从下标为2到下标为4之间的值（不包括下标为4的值）
        // var result4 = arr.slice(4, 2); //空
        // console.log("arr:" + arr); // ["a", "b", "c", "d", "e", "f"]
        // console.log("result1:" + result1); // ["c", "d", "e", "f"]
        // console.log("result2:" + result2); // ["e", "f"]
        // console.log("result3:" + result3); // ["c", "d"]
        // console.log("result4:" + result4); // []


        // sort
        // sort()方法要好好理解。所以，我们单独用一大段来讲。
        // 对数组的元素进行排序（会改变原来的数组）。
        // sort()方法举例：无参时
        // 如果在使用 sort() 方法时不带参，则默认按照字典序排序。
        // 举例 1：（当数组中的元素为字符串时）
        // var arr1 = ["e", "b", "d", "a", "f", "c"];
        // arr1.sort(); // 将数组 arr1 进行排序
        // console.log("arr1 =" + arr1);
        // 打印结果：
        // arr1 = ["a", "b", "c", "d", "e", "f"];
        // 举例 2：（当数组中的元素为数字时）
        // var arr2 = [5, 2, 11, 3, 4, 1];
        // arr2.sort(); // 将数组 arr2 进行排序
        // console.log("arr2 =" + arr2);
        // 打印结果：
        // arr2 = [1, 11, 2, 3, 4, 5]; // 其实是在对 ['5', '2', '11', '3', '4', '1']依据字典序排序
        // 上方的打印结果中，你会发现，使用 sort() 排序后，数字11竟然在数字2的前面。这是为什么呢？
        // 因为上面讲到了，sort()方法是按照字典序进行排序的。
        // sort()方法举例：带参时
        // 想实现真正意义上的排序，需要我们为sort提供一个函数作为参数，指定排序规则。
        // 回调函数中需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数。
        // 浏览器根据回调函数的返回值来决定元素的排序：（重要）
        // 如果返回一个大于 0 的值，则元素会交换位置
        // 如果返回一个小于 0 的值，则元素位置不变
        // 如果返回一个 0，则认为两个元素相等，则不交换位置
        // 代码举例：
        // var arr3 = [5, 2, 11, 3, 4, 1];
        // // 自定义排序规则
        // arr3.sort(function (a, b) {
        //     return a - b; // 升序排列
        //     // return b - a; // 降序排列
        // });
        // console.log("arr3 =" + arr3); // [1,2,3,4,5,11]





        // indexOf 和 lastIndexOf
        // 获取元素在数组当中的索引
        // 语法：
        // var idx = 数组.indexOf(value);
        // var idx = 数组.lastIndexOf(value);
        // 解释：
        // indexOf(value) ：从前往后匹配，获取 value 在数组中第一次出现的索引位置。
        // lastIndexOf(value) ：从后往前匹配，获取 value 在数组中第一次出现的索引位置。
        // 作用：
        // 利用这个方法，我们可以判断某个值是否在指定的数组中。如果没找到则返回 - 1。
        // var arr = ["a", "b", "c", "d", "e", "d", "c"];
        // console.log(arr.indexOf("c")); //从前往后，找第一个"c"在哪个位置,2
        // console.log(arr.lastIndexOf("d")); //从后往前，找第一个"d"在哪个位置,5



        // 和上面两个差不多效果
        // includes
        // 语法:
        // arr.includes(item, from)
        // 从索引 from 开始在数组中搜索 item，如果找到则返回 true（如果没找到，则返回 false）。
        // var arr = [1, 0, false];
        // alert(arr.indexOf(0)); // 1
        // alert(arr.indexOf(false)); // 2
        // alert(arr.indexOf(null)); // -1
        // alert(arr.includes(1)); // true
        // 请注意，这些方法使用的是严格相等 === 比较。
        // 如果我们想检查是否包含某个元素，并且不想知道确切的索引，那么 arr.includes 是首选



        // reverse
        // 翻转数组，返回翻转后后的数组（会改变原来的数组）。
        // var result = 数组.reverse();
        // var arr = ["a", "b", "c", "d", "e", "f"];
        // var result = arr.reverse(); // 将数组 arr 进行反转
        // console.log("arr =" + arr); // ["f","e","d","c","b","a"]
        // console.log("result =" + result); // ["f", "e", "d", "c", "b", "a"]
        // 从打印结果可以看出，原来的数组已经被改变了。


        // Array.isArray
        // 数组是基于对象的，所以 typeof 不能帮助从数组中区分出普通对象：
        // alert(typeof {}); // object
        // alert(typeof []); // object
        // 但是数组经常被使用，因此有一种特殊的方法用于判断：Array.isArray(value) 。如果 value 是一个数组，则返回 true；否则返回 false。
        // alert(Array.isArray({})); // false
        // alert(Array.isArray([])); // true
    </script>
</body>

</html>